home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2004 April / Gamestar_61_2004-04_dvdb.iso / DVDStar / Editace / hltp.exe / {app} / Applications / QuArK / quarkpy / mdlbtns.py < prev    next >
Text File  |  2004-01-05  |  8KB  |  321 lines
  1. """   QuArK  -  Quake Army Knife
  2.  
  3. Model Editor Buttons and implementation of editing commands
  4. """
  5. #
  6. # Copyright (C) 1996-99 Armin Rigo
  7. # THIS FILE IS PROTECTED BY THE GNU GENERAL PUBLIC LICENCE
  8. # FOUND IN FILE "COPYING.TXT"
  9. #
  10.  
  11. #$Header: /cvsroot/quark/runtime/quarkpy/mdlbtns.py,v 1.4 2000/08/21 21:33:04 aiv Exp $
  12.  
  13.  
  14.  
  15. import quarkx
  16. import qtoolbar
  17. from qdictionnary import Strings
  18. from mdlutils import *
  19.  
  20.  
  21.  
  22. #
  23. # Drag-and-drop functions
  24. #
  25.  
  26. def componentof(obj):
  27.   while not (obj is None):
  28.     obj = obj.parent
  29.     if obj is None:
  30.       return None
  31.     else:
  32.       if obj.type == ':mc':
  33.         return obj
  34.  
  35. def droptarget(editor, newitem):
  36.     "Where is the new item to be inserted ? (parent, insertbefore)"
  37.     ex = editor.layout.explorer
  38.     fs = ex.focussel     # currently selected item
  39.     if not newitem is None:
  40.       
  41.       if newitem.type==':mc':
  42.         return editor.Root, None
  43.       elif newitem.type==':mf':
  44.         if not fs is None:
  45.           c=componentof(fs)
  46.           if c is None:
  47.             c=editor.Root.currentcomponent
  48.           return c.group_frame, None
  49.       elif newitem.type in ('.jpg', '.pcx'):
  50.         if not fs is None:
  51.           c=componentof(fs)
  52.           if c is None:
  53.             c=editor.Root.currentcomponent
  54.           return c.group_skin, None
  55.       elif newitem.type==(':tag'):
  56.         return editor.Root.group_misc, None
  57.       elif newitem.type==(':bone'):
  58.         if editor.Root["no_skeleton"]=='1':
  59.           return editor.Root.group_misc, None
  60.         else: 
  61.           if not fs is None:
  62.             c=componentof(fs)
  63.             if c is None:
  64.               c=editor.Root.currentcomponent
  65.             return c.group_bone, None
  66. #    if editor.Root.acceptitem(newitem):
  67. #        return editor.Root, None   # in the root, at the end
  68.     # cannot insert new item at all...
  69.     return None, None
  70.  
  71.  
  72. def dropitemsnow(editor, newlist, text=Strings[544], center="S"):
  73.     "Drop new items into the given map editor."
  74.     #
  75.     # Known values of "center" :
  76.     #   <vector>: scroll at the given point
  77.     #   "S":      scroll at screen center or at the selected object's center
  78.     #   "0":      don't scroll at all
  79.     #   "+":      scroll at screen center or don't scroll at all
  80.     #
  81.     if len(newlist)==0:
  82.         return
  83.  
  84.     undo = quarkx.action()
  85.     ex = editor.layout.explorer
  86.     delta = None
  87.     if center != "0":
  88.         recenter = MapOption("Recenter", SS_MODEL)
  89.         if center != "+" or recenter:
  90.             bbox = quarkx.boundingboxof(newlist)
  91.             if not (bbox is None):
  92.                 if type(center)==type(""):
  93.                     if recenter:
  94.                         bbox1 = None
  95.                     else:
  96.                         bbox1 = quarkx.boundingboxof(editor.visualselection())
  97.                     if bbox1 is None:
  98.                         center = editor.layout.screencenter()
  99.                     else:
  100.                         center = (bbox1[0]+bbox1[1])*0.5
  101.                 delta = center - (bbox[0]+bbox[1])*0.5
  102.                 delta = editor.aligntogrid(delta)
  103.     for newitem in newlist:
  104.         nparent, nib = droptarget(editor, newitem)
  105.         if nparent is None:
  106.             undo.cancel()    # not required, but it's better when it's done
  107.             msg = Strings[-101]
  108.             quarkx.msgbox(msg, MT_ERROR, MB_OK)
  109.             return
  110.         new = newitem.copy()
  111.         prepareobjecttodrop(editor, new)
  112.         if delta:
  113.             new.translate(delta)
  114.         undo.put(nparent, new, nib)
  115.     undo.ok(editor.Root, text)
  116.     editor.layout.actionmpp()
  117.     return 1
  118.  
  119. def dropitemnow(editor, newitem):
  120.     "Drop a new item into the given map editor."
  121.     dropitemsnow(editor, [newitem], Strings[616])
  122.  
  123.  
  124.  
  125.  
  126. def replacespecifics(obj, mapping):
  127.     pass
  128.  
  129. def prepareobjecttodrop(editor, obj):
  130.     "Call this to prepare an object to be dropped. It replaces [auto] Specifics."
  131.  
  132.     oldincl = obj[";incl"]
  133.     obj[";desc"] = None
  134.     obj[";incl"] = None
  135.  
  136.  
  137.  
  138. def mdlbuttonclick(self):
  139.     "Drop a new model object from a button."
  140.     editor = mapeditor(SS_MODEL)
  141.     if editor is None: return
  142.     dropitemsnow(editor, map(lambda x: x.copy(), self.dragobject))
  143.  
  144.  
  145.  
  146. #
  147. # General editing commands.
  148. #
  149.  
  150. def deleteitems(root, list):
  151.     undo = quarkx.action()
  152.     text = None
  153.     for s in list:
  154.         if (s is not root) and checktree(root, s):    # only delete items that are childs of 'root'
  155.             if text is None:
  156.                 text = Strings[582] % s.shortname
  157.             else:
  158.                 text = Strings[579]   # multiple items selected
  159.             undo.exchange(s, None)   # replace all selected objects with None
  160.     if text is None:
  161.         undo.cancel()
  162.         quarkx.beep()
  163.     else:
  164.         undo.ok(root, text)
  165.  
  166.  
  167. def edit_del(editor, m=None):
  168.     deleteitems(editor.Root, editor.visualselection())
  169.  
  170. def edit_copy(editor, m=None):
  171.     quarkx.copyobj(editor.visualselection())
  172.  
  173. def edit_cut(editor, m=None):
  174.     edit_copy(editor, m)
  175.     edit_del(editor, m)
  176.  
  177. def edit_paste(editor, m=None):
  178.     newitems = quarkx.pasteobj(1)
  179.     try:
  180.         origin = m.origin
  181.     except:
  182.         origin = "+"
  183.     if not dropitemsnow(editor, newitems, Strings[543], origin):
  184.         quarkx.beep()
  185.  
  186. def edit_dup(editor, m=None):
  187.     if not dropitemsnow(editor, editor.visualselection(), Strings[541], "0"):
  188.         quarkx.beep()
  189.  
  190.  
  191. def edit_newgroup(editor, m=None):
  192.     "Create a new group."
  193.  
  194.     #
  195.     # List selected objects.
  196.     #
  197.  
  198.     list = editor.visualselection()
  199.  
  200.     #
  201.     # Build a new group object.
  202.     #
  203.  
  204.     newgroup = quarkx.newobj("group:m")
  205.  
  206.     #
  207.     # Determine where to drop this new group.
  208.     #
  209.  
  210.     ex = editor.layout.explorer
  211.     nparent = ex.focussel     # currently selected item
  212.     if not nparent is None:
  213.         nib = nparent
  214.         nparent = nparent.parent
  215.     if nparent is None:
  216.         nparent = editor.Root
  217.         nib = None
  218.  
  219.     #
  220.     # Do it !
  221.     #
  222.  
  223.     undo = quarkx.action()
  224.     undo.put(nparent, newgroup, nib)   # actually create the new group
  225.     for s in list:
  226.         if s is not editor.Root and s is not nparent:
  227.             undo.move(s, newgroup)   # put the selected items into the new group
  228.     undo.ok(editor.Root, Strings[556])
  229.  
  230.     #
  231.     # Initially expand the new group.
  232.     #
  233.  
  234.     editor.layout.explorer.expand(newgroup)
  235.  
  236.  
  237.  
  238.  
  239. def moveselection(editor, text, offset=None, matrix=None, origin=None, inflate=None):
  240.     "Move the selection and/or apply a linear mapping on it."
  241.  
  242.     #
  243.     # Get the list of selected items.
  244.     #
  245.     items = editor.visualselection()
  246.     if len(items):
  247.         if matrix and (origin is None):
  248.             #
  249.             # Compute a suitable origin if none is given
  250.             #
  251.             origin = editor.interestingpoint()
  252.             if origin is None:
  253.                 bbox = quarkx.boundingboxof(items)
  254.                 if bbox is None:
  255.                     origin = quarkx.vect(0,0,0)
  256.                 else:
  257.                     origin = (bbox[0]+bbox[1])*0.5
  258.  
  259.         undo = quarkx.action()
  260.         for obj in items:
  261.             new = obj.copy()
  262.             if offset:
  263.                 new.translate(offset)     # offset the objects
  264.             if matrix:
  265.                 new.linear(origin, matrix)   # apply the linear mapping
  266.             if inflate:
  267.                 new.inflate(inflate)    # inflate / deflate
  268.             undo.exchange(obj, new)
  269.         editor.ok(undo, text)
  270.  
  271.     else:
  272.         #
  273.         # No selection.
  274.         #
  275.         quarkx.msgbox(Strings[222], MT_ERROR, MB_OK)
  276.  
  277.  
  278.  
  279. def ForceToGrid(editor, grid, sellist):
  280.     undo = quarkx.action()
  281.     for obj in sellist:
  282.         new = obj.copy()
  283.         new.forcetogrid(grid)
  284.         undo.exchange(obj, new)
  285.     editor.ok(undo, Strings[560])
  286.  
  287.  
  288. def groupcolor(m):
  289.     editor = mapeditor(SS_MODEL)
  290.     if editor is None: return
  291.     group = editor.layout.explorer.uniquesel
  292.     if (group is None) or (group.type != ':mc'):
  293.         return
  294.     oldval = group["_color"]
  295.     if m.rev:
  296.         nval = None
  297.     else:
  298.         try:
  299.             oldval = quakecolor(quarkx.vect(oldval))
  300.         except:
  301.             oldval = 0
  302.         nval = editor.form.choosecolor(oldval)
  303.         if nval is None: return
  304.         nval = str(colorquake(nval))
  305.     if nval != oldval:
  306.         undo = quarkx.action()
  307.         undo.setspec(group, "_color", nval)
  308.         undo.ok(editor.Root, Strings[622])
  309.  
  310. # ----------- REVISION HISTORY ------------
  311. #
  312. #
  313. #$Log: mdlbtns.py,v $
  314. #Revision 1.4  2000/08/21 21:33:04  aiv
  315. #Misc. Changes / bugfixes
  316. #
  317. #Revision 1.2  2000/06/02 16:00:22  alexander
  318. #added cvs headers
  319. #
  320. #
  321. #